SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Immutable object</title>

</head>

Immutable object

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">"Immutable" and "Immutability" redirect here. For the Christian doctrine, see <a href="Immutability_(theology)" title="Immutability (theology)">Immutability (theology)</a>. For the album, see <a href="Immutable_(album)" title="Immutable (album)">Immutable (album)</a>. For the crypto gaming company, see <a href="Immutable_Pty_Ltd" class="mw-redirect" title="Immutable Pty Ltd">Immutable Pty Ltd</a>.</div>

In <a href="Object-oriented_computer_programming" class="mw-redirect" title="Object-oriented computer programming">object-oriented</a> (OO) and <a href="Functional_programming" title="Functional programming">functional</a> programming, an immutable object (unchangeable<a href="#cite_note-1">[1]</a> object) is an <a href="Object_(computer_science)" title="Object (computer science)">object</a> whose <a href="State_(computer_science)" title="State (computer science)">state</a> cannot be modified after it is created.<a href="#cite_note-Goetz-2">[2]</a> This is in contrast to a mutable object (changeable object), which can be modified after it is created.<a href="#cite_note-3">[3]</a> In some cases, an object is considered immutable even if some internally used attributes change, but the object's state appears unchanging from an external point of view. For example, an object that uses <a href="Memoization" title="Memoization">memoization</a> to cache the results of expensive computations could still be considered an immutable object.

Strings and other concrete objects are typically expressed as immutable objects to improve readability and runtime efficiency in object-oriented programming. Immutable objects are also useful because they are inherently <a href="Thread_safety" title="Thread safety">thread-safe</a>.<a href="#cite_note-Goetz-2">[2]</a> Other benefits are that they are simpler to understand and reason about and offer higher security than mutable objects.<a href="#cite_note-Goetz-2">[2]</a>

<div class="mw-heading mw-heading2"><h2 id="Concepts">Concepts</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Immutable_variables">Immutable variables</h3></div>

In <a href="Imperative_programming" title="Imperative programming">imperative programming</a>, values held in <a href="Program_variable" class="mw-redirect" title="Program variable">program variables</a> whose content never changes are known as <a href="Constant_(programming)" class="mw-redirect" title="Constant (programming)">constants</a> to differentiate them from variables that could be altered during execution. Examples include conversion factors from meters to feet, or the value of <a href="Pi" title="Pi">pi</a> to several decimal places.

Read-only fields may be calculated when the program runs (unlike constants, which are known beforehand), but never change after they are initialized.

<div class="mw-heading mw-heading3"><h3 id="Weak_vs_strong_immutability">Weak vs strong immutability</h3></div>

Sometimes, one talks of certain fields of an object being immutable. This means that there is no way to change those parts of the object state, even though other parts of the object may be changeable (weakly immutable). If all fields are immutable, then the object is immutable. If the whole object cannot be extended by another class, the object is called strongly immutable.<a href="#cite_note-4">[4]</a> This might, for example, help to explicitly enforce certain invariants about certain data in the object staying the same through the lifetime of the object. In some languages, this is done with a keyword (e.g. <code>const</code> in <a href="C%2B%2B" title="C++">C++</a>, <code>final</code> in <a href="Java_(programming_language)" title="Java (programming language)">Java</a>) that designates the field as immutable. Some languages reverse it: in <a href="OCaml" title="OCaml">OCaml</a>, fields of an object or record are by default immutable, and must be explicitly marked with <code>mutable</code> to be so.

<div class="mw-heading mw-heading3"><h3 id="References_to_objects">References to objects</h3></div>

In most <a href="Object-oriented_programming_language" class="mw-redirect" title="Object-oriented programming language">object-oriented languages</a>, objects can be referred to using <a href="Reference_(computer_science)" title="Reference (computer science)">references</a>. Some examples of such languages are <a href="Java_(programming_language)" title="Java (programming language)">Java</a>, <a href="C%2B%2B" title="C++">C++</a>, <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>, <a href="VB.NET" class="mw-redirect" title="VB.NET">VB.NET</a>, and many <a href="Scripting_language" title="Scripting language">scripting languages</a>, such as <a href="Perl" title="Perl">Perl</a>, <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, and <a href="Ruby_programming_language" class="mw-redirect" title="Ruby programming language">Ruby</a>. In this case, it matters whether the state of an object can vary when objects are shared via references.

<div class="mw-heading mw-heading3"><h3 id="Referencing_vs_copying_objects">Referencing vs copying objects</h3></div>

If an object is known to be immutable, it is preferred to create a <a href="Reference_(computer_science)" title="Reference (computer science)">reference</a> of it instead of copying the entire object. This is done to conserve memory by preventing data duplication and avoid calls to constructors and destructors; it also results in a potential boost in execution speed.

The reference copying technique is much more difficult to use for mutable objects, because if any user of a mutable object reference changes it, all other users of that reference see the change. If this is not the intended effect, it can be difficult to notify the other users to have them respond correctly. In these situations, <a href="Defensive_copy" class="mw-redirect" title="Defensive copy">defensive copying</a> of the entire object rather than the reference is usually an easy but costly solution. The <a href="Observer_pattern" title="Observer pattern">observer pattern</a> is an alternative technique for handling changes to mutable objects.

<div class="mw-heading mw-heading3"><h3 id="Copy-on-write">Copy-on-write</h3></div>

A technique that blends the advantages of mutable and immutable objects, and is supported directly in almost all modern hardware, is <a href="Copy-on-write" title="Copy-on-write">copy-on-write</a> (COW). Using this technique, when a user asks the system to copy an object, it instead merely creates a new reference that still points to the same object. As soon as a user attempts to modify the object through a particular reference, the system makes a real copy, applies the modification to that, and sets the reference to refer to the new copy. The other users are unaffected, because they still refer to the original object. Therefore, under COW, all users appear to have a mutable version of their objects, although in the case that users do not modify their objects, the space-saving and speed advantages of immutable objects are preserved. Copy-on-write is popular in <a href="Virtual_memory" title="Virtual memory">virtual memory</a> systems because it allows them to save memory space while still correctly handling anything an application program might do.

<div class="mw-heading mw-heading3"><h3 id="Interning">Interning</h3></div>

The practice of always using references in place of copies of equal objects is known as <a href="Intern_(computer_science)" class="mw-redirect" title="Intern (computer science)">interning</a>. If interning is used, two objects are considered equal <a href="If_and_only_if" title="If and only if">if and only if</a> their references, typically represented as pointers or integers, are equal. Some languages do this automatically: for example, <a href="Python_(programming_language)" title="Python (programming language)">Python</a> automatically <a href="String_intern_pool" class="mw-redirect" title="String intern pool">interns short strings</a>. If the algorithm that implements interning is guaranteed to do so in every case that it is possible, then comparing objects for equality is reduced to comparing their pointers – a substantial gain in speed in most applications. (Even if the algorithm is not guaranteed to be comprehensive, there still exists the possibility of a <a href="Fast_path" title="Fast path">fast path</a> case improvement when the objects are equal and use the same reference.) Interning is generally only useful for immutable objects.

<div class="mw-heading mw-heading3"><h3 id="Thread_safety">Thread safety</h3></div>

Immutable objects can be useful in multi-threaded applications. Multiple threads can act on data represented by immutable objects without concern of the data being changed by other threads. Immutable objects are therefore considered more <a href="Thread-safe" class="mw-redirect" title="Thread-safe">thread-safe</a> than mutable objects.

<div class="mw-heading mw-heading3"><h3 id="Violating_immutability">Violating immutability</h3></div>

Immutability does not imply that the object as stored in the computer's <a href="Computer_storage" class="mw-redirect" title="Computer storage">memory</a> is unwriteable. Rather, immutability is a <a href="Compile-time" class="mw-redirect" title="Compile-time">compile-time</a> construct that indicates what a programmer can do through the normal interface of the object, not necessarily what they can absolutely do (for instance, by circumventing the <a href="Type_system" title="Type system">type system</a> or violating <a href="Const_correctness" class="mw-redirect" title="Const correctness">const correctness</a> in <a href="C_(programming_language)" title="C (programming language)">C</a> or <a href="C%2B%2B" title="C++">C++</a>).

<div class="mw-heading mw-heading2"><h2 id="Language-specific_details">Language-specific details</h2></div>

In <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, <a href="Java_(programming_language)" title="Java (programming language)">Java</a><a href="#cite_note-Bloch-5">[5]</a>: 80 and the <a href=".NET_Framework" title=".NET Framework">.NET Framework</a>, strings are immutable objects. Both Java and the .NET Framework have mutable versions of string. In Java<a href="#cite_note-Bloch-5">[5]</a>: 84 these are <code><a href="StringBuffer" class="mw-redirect" title="StringBuffer">StringBuffer</a></code> and <code><a href="StringBuilder" class="mw-redirect" title="StringBuilder">StringBuilder</a></code> (mutable versions of Java <code><a rel="nofollow" class="external text" href="https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/lang/String.html">String</a></code>) and in .NET this is <code><a rel="nofollow" class="external text" href="http://msdn2.microsoft.com/en-us/library/system.text.stringbuilder.aspx">StringBuilder</a></code> (mutable version of .Net <code><a rel="nofollow" class="external text" href="http://msdn2.microsoft.com/en-us/library/system.string.aspx">String</a></code>). <a href="Python_3" class="mw-redirect" title="Python 3">Python 3</a> has a mutable string (bytes) variant, named <code>bytearray</code>.<a href="#cite_note-6">[6]</a>

Additionally, all of the <a href="Primitive_wrapper_class" class="mw-redirect" title="Primitive wrapper class">primitive wrapper classes</a> in Java are immutable.

Similar patterns are the <a href="Immutable_interface" title="Immutable interface">Immutable Interface</a> and Immutable Wrapper.

In pure <a href="Functional_programming" title="Functional programming">functional programming</a> languages it is not possible to create mutable objects without extending the language (e.g. via a mutable references library or a <a href="Foreign_function_interface" title="Foreign function interface">foreign function interface</a>), so all objects are immutable.

In <a href="Ada_(programming_language)" title="Ada (programming language)">Ada</a>, any object is declared either variable (i.e. mutable; typically the implicit default), or <code>constant</code> (i.e. immutable) via the <code>constant</code> keyword.

<div class="mw-highlight mw-highlight-lang-ada mw-content-ltr" dir="ltr"><pre> type Some_type is new Integer; -- could be anything more complicated

x: constant Some_type:= 1; -- immutable

y: Some_type; -- mutable

</pre></div>

Subprogram parameters are immutable in the in mode, and mutable in the in out and out modes.

<div class="mw-highlight mw-highlight-lang-ada mw-content-ltr" dir="ltr"><pre> procedure Do_it(a: in Integer; b: in out Integer; c: out Integer) is

begin

-- a is immutable

b:= b + a;

c:= a;

end Do_it;

</pre></div>

In <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> you can enforce immutability of the fields of a class with the <code>readonly</code> statement.<a href="#cite_note-Skeet-7">[7]</a>: 239

By enforcing all the fields as immutable, you obtain an immutable type.

<div class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><pre>class AnImmutableType

{

public readonly double _value;

public AnImmutableType(double x)

{

_value = x;

}

public AnImmutableType Square()

{

return new AnImmutableType(_value * _value);

}

}

</pre></div>

C# have records which are immutable.<a href="#cite_note-8">[8]</a><a href="#cite_note-9">[9]</a>

<div class="mw-highlight mw-highlight-lang-csharp mw-content-ltr" dir="ltr"><pre>record Person(string FirstName, string LastName);

</pre></div>

In C++, a <a href="Const-correctness" class="mw-redirect" title="Const-correctness">const-correct</a> implementation of <code>Cart</code> would allow the user to create instances of the class and then use them as either <code>const</code> (immutable) or mutable, as desired, by providing two different versions of the <code>items()</code> method. (Notice that in C++ it is not necessary — and in fact impossible — to provide a specialized constructor for <code>const</code> instances.)

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>class Cart {

public:

Cart(std::vector<Item> items): items_(items) {}

std::vector<Item>& items() { return items_; }

const std::vector<Item>& items() const { return items_; }

int ComputeTotalCost() const { /* return sum of the prices */ }

private:

};

</pre></div>

Note that, when there is a data member that is a pointer or reference to another object, then it is possible to mutate the object pointed to or referenced only within a non-const method.

C++ also provides abstract (as opposed to bitwise) immutability via the <code>mutable</code> keyword, which lets a <a href="Member_variable" title="Member variable">member variable</a> be changed from within a <code>const</code> method.

public:

if (total_cost_) {

return *total_cost_;

}

int total_cost = 0;

for (const auto& item : items_) {

total_cost += item.Cost();

}

total_cost_ = total_cost;

return total_cost;

}

private:

mutable std::optional<int> total_cost_;

};

</pre></div>

In <a href="D_(programming_language)" title="D (programming language)">D</a>, there exist two <a href="Type_qualifier" title="Type qualifier">type qualifiers</a>, <code>const</code> and <code>immutable</code>, for variables that cannot be changed.<a href="#cite_note-d_spec_const-10">[10]</a> Unlike C++'s <code>const</code>, Java's <code>final</code>, and C#'s <code>readonly</code>, they are transitive and recursively apply to anything reachable through references of such a variable. The difference between <code>const</code> and <code>immutable</code> is what they apply to: <code>const</code> is a property of the variable: there might legally exist mutable references to referred value, i.e. the value can actually change. In contrast, <code>immutable</code> is a property of the referred value: the value and anything transitively reachable from it cannot change (without breaking the type system, leading to <a href="Undefined_behavior" title="Undefined behavior">undefined behavior</a>). Any reference of that value must be marked <code>const</code> or <code>immutable</code>. Basically for any unqualified type <code>T</code>, <code>const(T)</code> is the disjoint union of <code>T</code> (mutable) and <code>immutable(T)</code>.

<div class="mw-highlight mw-highlight-lang-d mw-content-ltr" dir="ltr"><pre>class C {

/*mutable*/ Object mField;

const Object cField;

immutable Object iField;

}

</pre></div>

For a mutable <code>C</code> object, its <code>mField</code> can be written to. For a <code>const(C)</code> object, <code>mField</code> cannot be modified, it inherits <code>const</code>; <code>iField</code> is still immutable as it is the stronger guarantee. For an <code>immutable(C)</code>, all fields are immutable.

In a function like this:

<div class="mw-highlight mw-highlight-lang-d mw-content-ltr" dir="ltr"><pre>void func(C m, const C c, immutable C i)

{ /* inside the braces */ }

</pre></div>

Inside the braces, <code>c</code> might refer to the same object as <code>m</code>, so mutations to <code>m</code> could indirectly change <code>c</code> as well. Also,

<code>c</code> might refer to the same object as <code>i</code>, but since the value then is immutable, there are no changes. However, <code>m</code> and <code>i</code> cannot legally refer to the same object.

In the language of guarantees, mutable has no guarantees (the function might change the object), <code>const</code> is an outward-only guarantee that the function will not change anything, and

<code>immutable</code> is a bidirectional guarantee (the function will not change the value and the caller must not change it).

Values that are <code>const</code> or <code>immutable</code> must be initialized by direct assignment at the point of <a href="Declaration_(computer_programming)" title="Declaration (computer programming)">declaration</a> or by a <a href="Constructor_(object-oriented_programming)" title="Constructor (object-oriented programming)">constructor</a>.

Because <code>const</code> parameters forget if the value was mutable or not, a similar construct, <code>inout</code>, acts, in a sense, as a variable for mutability information.

A function of type <code>const(S) function(const(T))</code> returns <code>const(S)</code> typed values for mutable, const and immutable arguments. In contrast, a function of type <code>inout(S) function(inout(T))</code> returns <code>S</code> for mutable <code>T</code> arguments, <code>const(S)</code> for <code>const(T)</code> values, and <code>immutable(S)</code> for <code>immutable(T)</code> values.

Casting immutable values to mutable inflicts undefined behavior upon change, even if the original value comes from a mutable origin. Casting mutable values to immutable can be legal when there remain no mutable references afterward. "An expression may be converted from mutable (...) to immutable if the expression is unique and all expressions it transitively refers to are either unique or immutable."<a href="#cite_note-d_spec_const-10">[10]</a> If the <a href="Compiler" title="Compiler">compiler</a> cannot prove uniqueness, the casting can be done explicitly and it is up to the programmer to ensure that no mutable references exist.

The type <code>string</code> is an alias for <code>immutable(char)[]</code>, i.e. a typed slice of memory of immutable characters.<a href="#cite_note-11">[11]</a> Making substrings is cheap, as it just copies and modifies a pointer and a length filed, and safe, as the underlying data cannot be changed. Objects of type <code>const(char)[]</code> can refer to strings, but also to mutable buffers.

Making a shallow copy of a const or immutable value removes the outer layer of immutability: Copying an immutable string (<code>immutable(char[])</code>) returns a string (<code>immutable(char)[]</code>). The immutable pointer and length are being copied and the copies are mutable. The referred data has not been copied and keeps its qualifier, in the example <code>immutable</code>. It can be stripped by making a depper copy, e.g. using the <code>dup</code> function.

A classic example of an immutable object is an instance of the Java <code>String</code> class

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>String s = "ABC";

s.toLowerCase(); // This accomplishes nothing!

</pre></div>

The method <code>toLowerCase()</code> does not change the data "ABC" that <code>s</code> contains. Instead, a new String object is instantiated and given the data "abc" during its construction. A reference to this String object is returned by the <code>toLowerCase()</code> method. To make the String <code>s</code> contain the data "abc", a different approach is needed:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>s = s.toLowerCase();

</pre></div>

Now the String <code>s</code> references a new String object that contains "abc". There is nothing in the syntax of the declaration of the class String that enforces it as immutable; rather, none of the String class's methods ever affect the data that a String object contains, thus making it immutable.

The keyword <code>final</code> (<a href="Final_(Java)#Final_variables" title="Final (Java)">detailed article</a>) is used in implementing immutable primitive types and object references,<a href="#cite_note-12">[12]</a> but it cannot, by itself, make the objects themselves immutable. See below examples:

Primitive type variables (<code>int</code>, <code>long</code>, <code>short</code>, etc.) can be reassigned after being defined. This can be prevented by using <code>final</code>.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>int i = 42; //int is a primitive type

i = 43; // OK

final int j = 42;

j = 43; // does not compile. j is final so can't be reassigned

</pre></div>

Reference types cannot be made immutable just by using the <code>final</code> keyword. <code>final</code> only prevents reassignment.

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>final MyObject m = new MyObject(); //m is of reference type

m.data = 100; // OK. We can change state of object m (m is mutable and final doesn't change this fact)

m = new MyObject(); // does not compile. m is final so can't be reassigned

</pre></div>

Primitive wrappers (<code>Integer</code>, <code>Long</code>, <code>Short</code>, <code>Double</code>, <code>Float</code>, <code>Character</code>, <code>Byte</code>, <code>Boolean</code>) are also all immutable. Immutable classes can be implemented by following a few simple guidelines.<a href="#cite_note-13">[13]</a>

<div class="mw-heading mw-heading3"><h3 id="JavaScript">JavaScript</h3></div>

In <a href="JavaScript" title="JavaScript">JavaScript</a>, all primitive types (Undefined, Null, Boolean, Number, BigInt, String, Symbol) are immutable, but custom objects are generally mutable.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>function doSomething(x) { /* does changing x here change the original? */ };

var str = 'a string';

var obj = { an: 'object' };

doSomething(str); // strings, numbers and bool types are immutable, function gets a copy

doSomething(obj); // objects are passed in by reference and are mutable inside function

doAnotherThing(str, obj); // `str` has not changed, but `obj` may have.

</pre></div>

To simulate immutability in an object, one may define properties as read-only (writable: false).

Object.defineProperty(obj, 'foo', { value: 'bar', writable: false });

obj.foo = 'bar2'; // silently ignored

</pre></div>

However, the approach above still lets new properties be added. Alternatively, one may use <a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze">Object.freeze</a> to make existing objects immutable.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>var obj = { foo: 'bar' };

Object.freeze(obj);

obj.foo = 'bars'; // cannot edit property, silently ignored

obj.foo2 = 'bar2'; // cannot add property, silently ignored

</pre></div>

With the implementation of <a rel="nofollow" class="external text" href="https://tc39.es/ecma262/#sec-let-and-const-declarations">ECMA262</a>, JavaScript has the ability to create immutable references that cannot be reassigned. However, using a <code>const</code> declaration doesn't mean that value of the read-only reference is immutable, just that the name cannot be assigned to a new value.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const ALWAYS_IMMUTABLE = true;

try {

ALWAYS_IMMUTABLE = false;

} catch (err) {

console.log("Can't reassign an immutable reference.");

}

const arr = [1, 2, 3];

arr.push(4);

console.log(arr); // [1, 2, 3, 4]

</pre></div>

The use of immutable state has become a rising trend in JavaScript since the introduction of <a href="React_(JavaScript_library)" class="mw-redirect" title="React (JavaScript library)">React</a>, which favours Flux-like state management patterns such as <a href="Redux_(JavaScript_library)" title="Redux (JavaScript library)">Redux</a>.<a href="#cite_note-14">[14]</a>

In <a href="Perl" title="Perl">Perl</a>, one can create an immutable class with the Moo library by simply declaring all the attributes read only:

<div class="mw-highlight mw-highlight-lang-perl mw-content-ltr" dir="ltr"><pre>package Immutable;

use Moo;

has value => (

is => 'ro', # read only

default => 'data', # can be overridden by supplying the constructor with

# a value: Immutable->new(value => 'something else');

);

1;

</pre></div>

Creating an immutable class used to require two steps: first, creating accessors (either automatically or manually) that prevent modification of object attributes, and secondly, preventing direct modification of the instance data of instances of that class (this was usually stored in a hash reference, and could be locked with Hash::Util's lock_hash function):

<div class="mw-highlight mw-highlight-lang-perl mw-content-ltr" dir="ltr"><pre>package Immutable;

use strict;

use warnings;

use base qw(Class::Accessor);

# create read-only accessors

__PACKAGE__->mk_ro_accessors(qw(value));

use Hash::Util 'lock_hash';

sub new {

my $class = shift;

return $class if ref($class);

die "Arguments to new must be key => value pairs\n"

unless (@_ % 2 == 0);

my %defaults = (

value => 'data',

);

my $obj = {

%defaults,

@_,

};

bless $obj, $class;

# prevent modification of the object data

lock_hash %$obj;

}

1;

</pre></div>

Or, with a manually written accessor:

<div class="mw-highlight mw-highlight-lang-perl mw-content-ltr" dir="ltr"><pre>package Immutable;

use strict;

use warnings;

use Hash::Util 'lock_hash';

sub new {

die "Arguments to new must be key => value pairs\n"

value => 'data',

);

my $obj = {

%defaults,

@_,

};

# prevent modification of the object data

lock_hash %$obj;

}

# read-only accessor

sub value {

my $self = shift;

if (my $new_value = shift) {

# trying to set a new value

die "This object cannot be modified\n";

} else {

return $self->{value}

}

}

1;

</pre></div>

In <a href="PHP" title="PHP">PHP</a> have readonly properties since version 8.1 and readonly classes since version 8.2.<a href="#cite_note-15">[15]</a><a href="#cite_note-16">[16]</a>

<div class="mw-highlight mw-highlight-lang-php mw-content-ltr" dir="ltr"><pre>readonly class BlogData

{

public string $title;

public Status $status;

public function __construct(string $title, Status $status)

{

$this->title = $title;

$this->status = $status;

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Python">Python</h3></div>

In <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, some built-in types (numbers, Booleans, strings, tuples, frozensets) are immutable, but custom classes are generally mutable. To simulate immutability in a class, one could override attribute setting and deletion to raise exceptions:

<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre>class ImmutablePoint:

"""An immutable class with two attributes 'x' and 'y'."""

__slots__ = ["x", "y"]

def __setattr__(self, *args):

raise TypeError("Can not modify immutable instance.")

__delattr__ = __setattr__

def __init__(self, x, y):

# We can no longer use self.value = value to store the instance data

# so we must explicitly call the superclass

super().__setattr__("x", x)

super().__setattr__("y", y)

</pre></div>

The standard library helpers <a rel="nofollow" class="external text" href="https://docs.python.org/3/library/collections.html#collections.namedtuple"><code>collections.namedtuple</code></a> and <a rel="nofollow" class="external text" href="https://docs.python.org/3/library/typing.html#typing.NamedTuple"><code>typing.NamedTuple</code></a>, available from Python 3.6 onward, create simple immutable classes. The following example is roughly equivalent to the above, plus some tuple-like features:

<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre>from typing import NamedTuple

import collections

Point = collections.namedtuple("Point", ["x", "y"])

# the following creates a similar namedtuple to the above

class Point(NamedTuple):

x: int

y: int

</pre></div>

Introduced in Python 3.7, <a rel="nofollow" class="external text" href="https://docs.python.org/3/library/dataclasses.html"><code>dataclasses</code></a> allow developers to emulate immutability with <a rel="nofollow" class="external text" href="https://docs.python.org/3/library/dataclasses.html#frozen-instances">frozen instances</a>. If a frozen dataclass is built, <code>dataclasses</code> will override <code>__setattr__()</code> and <code>__delattr__()</code> to raise <code>FrozenInstanceError</code> if invoked.

<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre>from dataclasses import dataclass

@dataclass(frozen=True)

class Point:

x: int

y: int

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Racket">Racket</h3></div>

<a href="Racket_(programming_language)" title="Racket (programming language)">Racket</a> substantially diverges from other <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a> implementations by making its core pair type ("cons cells") immutable. Instead, it provides a parallel mutable pair type, via <code>mcons</code>, <code>mcar</code>, <code>set-mcar!</code> etc. In addition, many immutable types are supported, for example, immutable strings and vectors, and these are used extensively. New structs are immutable by default, unless a field is specifically declared mutable, or the whole struct:

<div class="mw-highlight mw-highlight-lang-racket mw-content-ltr" dir="ltr"><pre>(struct foo1 (x y)) ; all fields immutable

(struct foo2 (x [y #:mutable])) ; one mutable field

(struct foo3 (x y) #:mutable) ; all fields mutable

</pre></div>

The language also supports immutable hash tables, implemented functionally, and immutable dictionaries.

Rust's <a href="Rust_(programming_language)#Ownership" title="Rust (programming language)">ownership</a> system allows developers to declare immutable variables, and pass immutable references. By default, all variables and references are immutable. Mutable variables and references are explicitly created with the <code>mut</code> keyword.

<a rel="nofollow" class="external text" href="https://doc.rust-lang.org/reference/items/constant-items.html">Constant items</a> in Rust are always immutable.

<div class="mw-highlight mw-highlight-lang-rust mw-content-ltr" dir="ltr"><pre>// constant items are always immutable

const ALWAYS_IMMUTABLE: bool = true;

struct Object {

x: usize,

y: usize,

}

fn main() {

// explicitly declare a mutable variable

let mut mutable_obj = Object { x: 1, y: 2 };

mutable_obj.x = 3; // okay

let mutable_ref = &mut mutable_obj;

mutable_ref.x = 1; // okay

let immutable_ref = &mutable_obj;

immutable_ref.x = 3; // error E0594

// by default, variables are immutable

let immutable_obj = Object { x: 4, y: 5 };

immutable_obj.x = 6; // error E0596

let mutable_ref2 =

&mut immutable_obj; // error E0596

let immutable_ref2 = &immutable_obj;

immutable_ref2.x = 6; // error E0594

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Scala">Scala</h3></div>

In <a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a>, any entity (narrowly, a binding) can be defined as mutable or immutable: in the declaration, one can use <code>val</code> (value) for immutable entities and <code>var</code> (variable) for mutable ones. Note that even though an immutable binding can not be reassigned, it may still refer to a mutable object and it is still possible to call mutating methods on that object: the binding is immutable, but the underlying object may be mutable.

For example, the following code snippet:

<div class="mw-highlight mw-highlight-lang-scala mw-content-ltr" dir="ltr"><pre>val maxValue = 100

var currentValue = 1

</pre></div>

defines an immutable entity <code>maxValue</code> (the integer type is inferred at compile-time) and a mutable entity named <code>currentValue</code>.

By default, collection classes such as <code>List</code> and <code>Map</code> are immutable, so update-methods return a new instance rather than mutating an existing one. While this may sound inefficient, the implementation of these classes and their guarantees of immutability mean that the new instance can re-use existing nodes, which, especially in the case of creating copies, is very efficient.<a href="#cite_note-17">[17]</a>

<ul><li><a href="Clojure" title="Clojure">Clojure</a></li>

<li><a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a></li>

<li><a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a></li>

<li><a href="Mutator_method" title="Mutator method">Mutator method</a></li>

<li><a href="Prolog" title="Prolog">Prolog</a></li>

<li><a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a></li>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

This article contains some material from the <a href="Perl_Design_Patterns_Book" title="Perl Design Patterns Book">Perl Design Patterns Book</a>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.oxfordlearnersdictionaries.com/definition/english/immutable">"immutable adjective - Definition, pictures, pronunciation and usage notes - Oxford Advanced Learner's Dictionary at OxfordLearnersDictionaries.com"</a>. www.oxfordlearnersdictionaries.com.</cite>

</li>

<li id="cite_note-Goetz-2">^ <a href="#cite_ref-Goetz_2-0">a</a> <a href="#cite_ref-Goetz_2-1">b</a> <a href="#cite_ref-Goetz_2-2">c</a> Goetz et al. Java Concurrency in Practice. Addison Wesley Professional, 2006, Section 3.4. Immutability

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.mit.edu/6.005/www/fa16/classes/09-immutability/">"6.005 — Software Construction"</a>.</cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite id="CITEREFDavid_O'Meara2003" class="citation web cs1">David O'Meara (April 2003). <a rel="nofollow" class="external text" href="http://www.javaranch.com/journal/2003/04/immutable.htm">"Mutable and Immutable Objects: Make sure methods can't be overridden"</a>. Java Ranch. Retrieved 2012-05-14. <q>The preferred way is to make the class final. This is sometimes referred to as "Strong Immutability". It prevents anyone from extending your class and accidentally or deliberately making it mutable.</q></cite>

</li>

<li id="cite_note-Bloch-5">^ <a href="#cite_ref-Bloch_5-0">a</a> <a href="#cite_ref-Bloch_5-1">b</a> <cite id="CITEREFBloch2018" class="citation book cs1">Bloch, Joshua (2018). "Effective Java: Programming Language Guide" (third ed.). Addison-Wesley. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0134685991</bdi>.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.python.org/release/3.0/library/functions.html#bytearray">"Built-in Functions — Python v3.0 documentation"</a>. docs.python.org.</cite>

</li>

<li id="cite_note-Skeet-7"><a href="#cite_ref-Skeet_7-0">^</a> <cite id="CITEREFSkeet2019" class="citation book cs1">Skeet, Jon (23 March 2019). C# in Depth. Manning. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1617294532</bdi>.</cite>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://learn.microsoft.com/en-us/dotnet/csharp/tutorials/records">"Use record types - C# tutorial - C#"</a>. learn.microsoft.com. 14 November 2023. Retrieved 23 February 2024.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record">"Records - C# reference - C#"</a>. learn.microsoft.com. 25 May 2023. Retrieved 23 February 2024.</cite>

</li>

<li id="cite_note-d_spec_const-10">^ <a href="#cite_ref-d_spec_const_10-0">a</a> <a href="#cite_ref-d_spec_const_10-1">b</a> <a rel="nofollow" class="external text" href="https://dlang.org/spec/const3.html">D Language Specification § 18</a>

</li>

<li id="cite_note-11"><a href="#cite_ref-11">^</a> <a rel="nofollow" class="external text" href="https://dlang.org/spec/arrays.html#strings">D Language Specification § 12.16</a> (The terms array and slice are used interchangeably.)

</li>

<li id="cite_note-12"><a href="#cite_ref-12">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://javarevisited.blogspot.co.uk/2013/03/how-to-create-immutable-class-object-java-example-tutorial.html">"How to create Immutable Class and Object in Java – Tutorial Example"</a>. Javarevisited.blogspot.co.uk. 2013-03-04. Retrieved 2014-04-14.</cite>

</li>

<li id="cite_note-13"><a href="#cite_ref-13">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.javapractices.com/topic/TopicAction.do?Id=29">"Immutable objects"</a>. javapractices.com. Retrieved November 15, 2012.</cite>

</li>

<li id="cite_note-14"><a href="#cite_ref-14">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://desalasworks.com/article/immutability-in-javascript-a-contrarian-view/">"Immutability in JavaScript: A Contrarian View"</a>. Desalasworks.</cite>

</li>

<li id="cite_note-15"><a href="#cite_ref-15">^</a> <a rel="nofollow" class="external free" href="https://www.php.net/releases/8.1/en.php#readonly_properties">https://www.php.net/releases/8.1/en.php#readonly_properties</a>

</li>

<li id="cite_note-16"><a href="#cite_ref-16">^</a> <a rel="nofollow" class="external free" href="https://www.php.net/releases/8.2/en.php#readonly_classes">https://www.php.net/releases/8.2/en.php#readonly_classes</a>

</li>

<li id="cite_note-17"><a href="#cite_ref-17">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.scala-lang.org/docu/files/collections-api/collections_12.html">"Scala 2.8 Collections API – Concrete Immutable Collection Classes"</a>. Scala-lang.org. Retrieved 2014-04-14.</cite>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .side-box{margin:4px 0;box-sizing:border-box;border:1px solid #aaa;font-size:88%;line-height:1.25em;background-color:var(--background-color-interactive-subtle,#f8f9fa);display:flow-root}.mw-parser-output .infobox .side-box{font-size:100%}.mw-parser-output .side-box-abovebelow,.mw-parser-output .side-box-text{padding:0.25em 0.9em}.mw-parser-output .side-box-image{padding:2px 0 2px 0.9em;text-align:center}.mw-parser-output .side-box-imageright{padding:2px 0.9em 2px 0;text-align:center}@media(min-width:500px){.mw-parser-output .side-box-flex{display:flex;align-items:center}.mw-parser-output .side-box-text{flex:1;min-width:0}}@media(min-width:720px){.mw-parser-output .side-box{width:238px}.mw-parser-output .side-box-right{clear:right;float:right;margin-left:1em}.mw-parser-output .side-box-left{margin-right:1em}}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1237033735">

/* start https://en.wikipedia.org/ */

@media print{body.ns-0 .mw-parser-output .sistersitebox{display:none!important}}@media screen{html.skin-theme-clientpref-night .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}

/* end https://en.wikipedia.org/ */

</style><div class="side-box side-box-right sistersitebox"><style data-mw-deduplicate="TemplateStyles:r1126788409">

/* start https://en.wikipedia.org/ */

.mw-parser-output .plainlist ol,.mw-parser-output .plainlist ul{line-height:inherit;list-style:none;margin:0;padding:0}.mw-parser-output .plainlist ol li,.mw-parser-output .plainlist ul li{margin-bottom:0}

/* end https://en.wikipedia.org/ */

</style>

<div class="side-box-text plainlist">Look up <a href="https://en.wiktionary.org/wiki/mutable" class="extiw external" title="wiktionary:mutable">mutable</a> in Wiktionary, the free dictionary.</div></div>

</div>

<ul><li><a rel="nofollow" class="external text" href="https://www.codeproject.com/Articles/1043301/Immutable-objects-in-Csharp">Immutable objects in C#</a> using 3 simple steps.</li>

<li>Article <a rel="nofollow" class="external text" href="https://web.archive.org/web/20101020235317/http://www.ibm.com/developerworks/java/library/j-jtp02183.html">Java theory and practice: To mutate or not to mutate?</a> by Brian Goetz, from IBM DeveloperWorks – <a rel="nofollow" class="external text" href="https://web.archive.org/web/20101020235317/http://www.ibm.com/developerworks/java/library/j-jtp02183.html">saved copy at Internet Archive</a> by Brian Goetz, from IBM DeveloperWorks – <a rel="nofollow" class="external text" href="https://web.archive.org/web/20101020235317/http://www.ibm.com/developerworks/java/library/j-jtp02183.html">saved copy at Internet Archive</a></li>

<li><a rel="nofollow" class="external text" href="http://www.javapractices.com/Topic29.cjp">Immutable objects</a> from JavaPractices.com</li>

<li><a rel="nofollow" class="external text" href="http://c2.com/cgi/wiki?ImmutableObject">Immutable objects</a> from <a href="Portland_Pattern_Repository" title="Portland Pattern Repository">Portland Pattern Repository</a></li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20150809185757/http://facebook.github.io/immutable-js/">Immutable.js</a> by Facebook</li>

<li><a rel="nofollow" class="external text" href="https://persistent.codeplex.com/">Immutable structures in C#</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20171221010951/http://persistent.codeplex.com/">Archived</a> 2017-12-21 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> opensource project in Codeplex</li>

<li><a rel="nofollow" class="external text" href="https://msdn.microsoft.com/en-us/library/system.collections.immutable(v=vs.111).aspx">Immutable collections in .NET</a> official library by Microsoft</li>

<li><a rel="nofollow" class="external text" href="https://www.tutlane.com/tutorial/csharp/csharp-string-with-examples#divcsstimu">Immutable objects in C#</a> by Tutlane.com</li></ul></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-08-02" href="https://en.wikipedia.org/wiki/?title=Immutable_object&oldid=1303900666">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>